package com.job.meituan;

import java.util.Scanner;

/**
 * @author angzhijin
 * @Description
 * @create 2022-08-27 3:54 下午
 */
public class Meituan0827 {

    public static void main(String[] args) {
//        B();

        D();

//        E();
    }

    /**
     * 神奇字符
     * 时间限制： 3000MS
     * 内存限制： 589824KB
     * 题目描述：
     * 小美在摆弄她的字符串。最近小团送了小美一个特殊字符 ' * '，这个字符可以和其他所有字符匹配，除了这个字符外，其他字符只能自己和自己匹配。小美先前有一个字符串S，长度为n，现在她又新组合了一个可有特殊字符 ' * ' 的字符串s，长度为m。小美想知道有多少个位置 i，使得S[i+j]与s[j]对于1≤j≤m均能匹配上？其中X[y]代表字符串X中第y位的字符。
     *
     *
     *
     * 输入描述
     * 第一行两个空格隔开的正整数n和m，分别表示字符串S和字符串s的长度。
     *
     * 接下来一行长度为n的仅包含小写英文字母的字符串S
     *
     * 接下来一行长度为m的包含小写英文字母以及特殊字符 ' * ' 的字符串s
     *
     * 对于所有数据，1≤m≤n≤2000
     *
     * 输出描述
     * 输出一行一个整数，表示满足要求的位置数量
     *
     *
     * 样例输入
     * 7 3
     * abcaacc
     * a*c
     * 样例输出
     * 3
     */
    public static void A() {
        Scanner sc = new Scanner(System.in);
        int n =sc.nextInt();
        int m = sc.nextInt();
        sc.nextLine();
        char[] S = sc.nextLine().toCharArray();
        char[] s = sc.nextLine().toCharArray();
        int count =0;
        for (int i = 0; i <= n-m; i++) {
            if(s[0]=='*' || S[i] == s[0]){
                int j=1;
                boolean flag =true;
                while (flag && j<m){
                    if(!(s[j]=='*' || S[i+j]==s[j]))
                        flag=false;
                    j++;
                }
                if(flag)
                    count++;
            }
        }
        System.out.println(count);
    }


    /**
     * 挑剔
     * 时间限制： 3000MS
     * 内存限制： 589824KB
     * 题目描述：
     * 小美有一个精致的珠宝链子。初始这个链子上有n个宝石，从左到右分别编号为1~n （宝石上的编号不会因为交换位置而改变编号）。接着，小美为了美观对这个项链进行微调，有m次操作，每次选择一个编号 x ,将编号 x 的宝石放到最左边（不改变其他宝石的相对位置）。小美想知道，所有操作完成后最终链子从左到右宝石编号是多少。
     *
     *
     *
     * 输入描述
     * 第一行两个正整数n和m，分别表示链子上的宝石数和操作次数。
     *
     * 接下来一行m个数 x1,x2,...,xm ，依次表示每次操作选择的编号x值。
     *
     * 数字间两两有空格隔开
     *
     * 对于所有数据，1≤m,n≤50000, 1≤xi≤n
     *
     * 输出描述
     * 输出一行 n 个整数，表示答案。
     *
     *
     * 样例输入
     * 5 3
     * 2 3 4
     * 样例输出
     * 4 3 2 1 5
     *
     * 提示
     * 第一次微调完，链子为 2 1 3 4 5
     *
     * 第二次微调完，链子为 3 2 1 4 5
     *
     * 第三次微调完，链子为 4 3 2 1 5
     */
    public static void B() {
        Scanner sc = new Scanner(System.in);
        int n =sc.nextInt();
        int m = sc.nextInt();
        int[] op = new int[m];
        for (int i = 0; i < m; i++) {
            op[i] = sc.nextInt();
        }
        int[] oped = new int[n+1];
        String[] res = new String[n];
        int index =0;
        int i = m-1;
        while (i>=0){
            if(oped[op[i]]==0) {
                res[index]=String.valueOf(op[i]);
                oped[op[i]] =1;
                index++;
            }
            i--;
        }
        i = 1;
        while(i<=n){
            if(oped[i]==0){
                res[index]=String.valueOf(i);
                index++;
            }
            i++;
        }
        System.out.println(String.join(" ", res));
    }


    /**
     * 裁缝
     * 时间限制： 3000MS
     * 内存限制： 589824KB
     * 题目描述：
     * 小团最近获得了美美团团国的裁缝资格证，成为了一个裁缝！现在小团有一个长度为n的大布料S（在这个国家布料其实是一个仅包含小写英文字母的字符串），小团可以将布料在任意位置剪切，例如布料abcd可以被裁剪为a与bcd 或ab与cd或abc与d ，不过，裁剪完之后是不能拼接起来的，因为小团还不是很擅长拼接布料。现在小团想知道能不能有一种裁剪方式能让他把布料恰好裁剪成客人要求的小布料。
     *
     * 形式化地，有一个串S，问是否能将其划分成m个不相交的连续子串，使得这些连续子串可以与要求的连续子串一 一对应。两个串相对应是指这两个串完全相等。例如"aab"="aab" 但 "aab"≠"baa"
     *
     *
     *
     * 输入描述
     * 第一行两个空格隔开的正整数n和m，分别表示大布料S长度和客人要求的小布料数量。
     *
     * 接下来一行一个长度为n的仅包含小写英文字母的串S，表示大布料的组成。
     *
     * 接下来一行m个空格隔开的数x1,x2, ...,xm ，依次表示所要求的小布料长度。
     *
     * 接下来开始m行，每行一个长度为xi的仅包含小写英文字母的串si，表示第i个小布料的组成。
     *
     * 对于所有数据，
     *
     * 输出描述
     * 如果存在这样的方案，输出方案总数。如果不存在任何方案，输出0。两个方案A、B不相同当且仅当方案A中存在一个相对于原始长布料的裁剪位置i，而方案B中并未在该位置i裁剪。
     *
     * 例如aaaaaa 裁剪方案aaa|aaa 与方案 aaa|aaa是相同的方案。而方案aa|aaaa与方案aaaa|aa是不同的方案，虽然划分出的结果都是aa与aaaa，但前者在第二个a处进行了裁剪，后者并没有在这里进行裁剪，所以视为不同的裁剪方案。
     *
     * 样例输入
     * 6 2
     * aaaaaa
     * 4 2
     * aaaa
     * aa
     * 样例输出
     * 2
     *
     * 提示
     * 有两种方案，第一种是aaaa|aa，第二种是aa|aaaa，代表一次裁剪。
     */
    public static void C() {
        Scanner sc = new Scanner(System.in);
        int n =sc.nextInt();  // 大布料长度
        int m = sc.nextInt(); // 小布料数目
        sc.nextLine();
        char[] S = sc.nextLine().toCharArray(); //大布料
        int[] x = new int[m];
        for (int i = 0; i < m; i++) {
            x[i] = sc.nextInt(); // 小布料长度
        }
        sc.nextLine();
        String[] s = new String[m];
        for (int i = 0; i < m; i++) {
            s[i] = sc.nextLine(); // 小布料
        }


    }

    /**
     * 下雨
     * 时间限制： 3000MS
     * 内存限制： 589824KB
     * 题目描述：
     * 小团正忙着用机器人收衣服！因为快要下雨了，小团找来了不少机器人帮忙收衣服。他有n件衣服从左到右成一行排列，所在位置分别为1~n，在每个位置上已经有一个就绪的机器人可以帮忙收衣服，但第 i 个位置上的机器人需要pi的电量来启动，然后这个机器人会用ti的时间收衣服，当它收完当前衣服后，会尝试去收紧邻的右边的一件衣服(如果存在的话)，即 i+1处的衣服，如果 i+1 处的衣服已经被其他机器人收了或者其他机器人正在收，这个机器人就会进入休眠状态，不再收衣服。不过如果机器人没有休眠，它会同样以ti时间来收这件 i+1 处的衣服（注意，不是ti+1的时间，收衣服的时间为每个机器人固有属性），然后它会做同样的检测来看能否继续收 i+2 处的衣服，一直直到它进入休眠状态或者右边没有衣服可以收了。形象地来说，机器人会一直尝试往右边收衣服，收k件的话就耗费k*ti的时间，但是当它遇见其他机器人工作的痕迹，就会认为后面的事情它不用管了，开始摸鱼，进入休眠状态。
     *
     * 小团手里总共有电量b，他准备在0时刻的时候将所有他想启动的机器人全部一起启动，过后不再启动新的机器人，并且启动的机器人的电量之和不大于b。他想知道在最佳选择的情况下，最快多久能收完衣服。若无论如何怎样都收不完衣服，输出-1。
     *
     *
     *
     * 输入描述
     * 第一行两个正整数n和b，分别表示衣服数量和小团持有电量。
     *
     * 接下来一行n个数 p1,p2, ...,pn ，含义如题所述，为机器人唤醒需求电量。
     *
     * 接下来一行n个数 t1,t2, ...,tn，含义如题所述，为机器人收衣服所需时间。
     *
     * 数字间两两有空格隔开。
     *
     * 对于所有数据，1≤n≤1000，1≤pi≤100, 1≤ti , b≤105
     *
     * 输出描述
     * 输出最短所需时间。
     *
     *
     * 样例输入
     * 3 5
     * 1 2 3
     * 7 5 3
     * 样例输出
     * 10
     *
     * 提示
     * 样例解释1
     *
     * 可以同时启动第一个机器人和第二个机器人，耗电量为1+2=3，这样花费时间为max(7, 5*2)=10
     *
     * 也可以同时启动第一个机器人和第三个机器人，耗电量为1+3=4，这样花费时间为max(7*2, 3)=14
     *
     * 所以答案为10
     *
     *
     *
     * 输入样例2
     *
     * 3 5
     *
     * 6 2 3
     *
     * 7 5 3
     *
     * 输出样例2
     *
     * -1
     *
     * 样例解释2
     *
     * 因为必须要启动第一个机器人，耗电量至少为6，但是持有电量只有5，因此无法收完所有衣服，输出-1
     */
    public static void D() {
        Scanner sc = new Scanner(System.in);
        int n =sc.nextInt();  // 衣服数
        int m = sc.nextInt(); // 电量
        int[] p = new int[n];
        int[] t = new int[n];
        for (int i = 0; i < n; i++) {
            p[i] = sc.nextInt();  // 启动所需电量
        }
        for (int i = 0; i < n; i++) {
            t[i] = sc.nextInt(); // 收衣服时间
        }
        if(p[0] > m){
            System.out.println(-1);
            return;
        }
        int currentBot = 0;
        int workTime =0;
        int res =0;
        for (int i = 0; i < n; i++) {
            if(i==0){ // 必须启动
                m-=p[i];
                workTime += t[currentBot];
            }else{
                workTime += t[currentBot];
                if(workTime>t[i] && m>p[i]){
                    workTime-=t[currentBot];
                    res = Math.max(res, workTime);
                    currentBot++;
                    m-=p[i];
                    workTime = t[currentBot];
                }
            }
        }
        res = Math.max(res, workTime);
        System.out.println(res);
    }


    /**
     * 回家
     * 时间限制： 3000MS
     * 内存限制： 589824KB
     * 题目描述：
     * 小美在回家路上碰见很多缠人的可爱猫猫！因为猫猫太可爱了以及小美十分有爱心，每遇到一只猫猫，小美忍不住停下来花费T的时间抚摸猫猫让猫猫不再缠着小美。而一路上小美能捡到很多亮闪闪的小玩具，这里我们给每个小玩具的种类都编了号，从1~k，一共k种小玩具，对于每个所属种类i的小玩具，小美可以选择将它送给遇到的一只猫猫玩，这样的话可以只花费ti的时间就可以让这只猫猫心满意足的离开。小美想知道，在她以最佳的对小玩具的用法下，她最少耗费多少时间在打发猫猫（即只考虑摸猫时间以及用小玩具打发猫的时间）。
     *
     * 注意，每个捡到的小玩具只能用一次。
     *
     *
     *
     * 输入描述
     * 第一行三个正整数n、k和T，分别表示小美回家遇见的事件数、小玩具种类总数以及摸猫时间！
     *
     * 接下来一行k个数t1,t2, ...,tk, 含义如题所述，为每种小玩具打发猫猫所用时间。
     *
     * 接下来一行n个数e1,e2, ...,en ，表示n次事件，对第i次事件，如果ei=0，则表示遇到了一只猫猫，小美可以选择花费T的时间去抚摸，或者用一个小玩具送给猫猫来打发它(如果小美有的话)。如果ei>0，则表示小美在这里捡到了一个小玩具，种类为ei。初始时候小美身上没有任何小玩具，她可以携带任意多个小玩具。
     *
     * 对于所有数据，1≤n≤50000，1≤k≤50000，0≤ei≤k, 1≤T,ti≤104
     *
     * 输出描述
     * 输出最少耗费多少时间在打发猫猫（即只考虑摸猫时间以及用小玩具打发猫的时间）。
     *
     *
     * 样例输入
     * 6 2 100
     * 1 50
     * 0 1 2 0 1 0
     * 样例输出
     * 102
     *
     * 提示
     * 样例解释
     *
     * 一开始没有小玩具，遇到一只猫猫只能抚摸，花费了100的时间。
     *
     * 接下来获得了小玩具1和2，然后遇到一只猫猫，用了小玩具1，只花费了1的时间。
     *
     * 接下来又获得一个小玩具1之后又遇见一只猫猫，因为又有小玩具1了，所以还是只用花费1的时间。
     *
     * 总共用时102
     */
    // 72
    public static void E() {
        Scanner sc = new Scanner(System.in);
        int n =sc.nextInt();
        int k = sc.nextInt();
        int T = sc.nextInt();
        int[] t = new int[k+1];
        for (int i = 1; i < k+1; i++) { // 玩具 1-k
            t[i] = sc.nextInt();
        }
        int[] e = new int[n];
        for (int i = 0; i < n; i++) {
            e[i] = sc.nextInt();
        }
        int[] toy = new int[k+1];
        int toyCount = 0;
        int time = 0;
        for (int i = 0; i < n; i++) {
            if(e[i]==0){ // 猫
                if(toyCount==0) //没玩具
                    time+=T;
                else{
                    int min = T;
                    int selectedToy =0;
                    for (int j = 1; j < k; j++) {
                        if(toy[j]>0 && t[j]<min){
                            min = t[j];
                            selectedToy = j;
                        }
                    }
                    if(selectedToy!=0){
                        time+=min;
                        toy[selectedToy]--;
                        toyCount--;
                    } else{
                        time+=T;
                    }
                }
            }else{
                toyCount+=1;
                toy[e[i]]++; // 玩具计数
            }

        }
        System.out.println(time);
    }
}
